#479033853

Committed 06 Nov 2026 12:50PM UTC coverage: 23.052% (+0.005%) from 23.047%

Build # #479033853

Build Type

Pull #259

github

Committed by

claude

Commit Message

Log packet encoding and decoding errors

When a packet fails to encode or decode, vanilla disconnects with
"Internal Exception" but only logs the cause at debug level, so it is
missing from latest.log. Log the full stack trace at error level, so
these disconnects can be diagnosed from regular logs.

The decoding error now names the packet class instead of a fresh
instance's toString, which also avoids an NPE when construction failed.

Related to #258

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UeSuG8Sp4V22VPUqWFGwM7

Pull Request Pull Request #259: Fix packets failing to decode when a map is modified while encoding, and log codec errors

Coverage Stats

2 of 6 new or added lines in 2 files covered. (33.33%)

28 existing lines in 1 file now uncovered.

2444 of 10602 relevant lines covered (23.05%)

0.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.83

/src/main/java/org/cyclops/cyclopscore/network/PacketCodec.java

package org.cyclops.cyclopscore.network;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.Vec3i;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.Tag;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.resources.ResourceKey;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.phys.Vec3;
import net.minecraftforge.fluids.FluidStack;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.cyclopscore.datastructure.SingleCache;
import org.cyclops.cyclopscore.inventory.ItemLocation;
import org.joml.Vector3d;

import javax.annotation.Nullable;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * Packet with automatic coding and decoding of basic fields annotated with {@link CodecField}.
 * @author rubensworks
 *
 */
public abstract class PacketCodec extends PacketBase {

    public static final int READ_STRING_MAX_LENGTH = 32767;

    private static Map<Class<?>, ICodecAction> codecActions = Maps.newHashMap();
    static {
        codecActions.put(String.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeUtf((String) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readUtf(32767); // The arg-less version is client-side only, so we copy its implementation.
            }
        });

        codecActions.put(double.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeDouble((Double) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readDouble();
            }
        });

        codecActions.put(int.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeInt((int) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readInt();
            }
        });

        codecActions.put(long.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeLong((long) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readLong();
            }
        });

        codecActions.put(short.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeShort((Short) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readShort();
            }
        });

        codecActions.put(boolean.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeBoolean((Boolean) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readBoolean();
            }
        });

        codecActions.put(float.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeFloat((Float) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readFloat();
            }
        });

        codecActions.put(Vector3d.class, new ICodecAction() {
            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                Vector3d v = (Vector3d)object;
                output.writeDouble(v.x);
                output.writeDouble(v.y);
                output.writeDouble(v.z);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                double x = input.readDouble();
                double y = input.readDouble();
                double z = input.readDouble();
                return new Vector3d(x, y, z);
            }
        });

        codecActions.put(Vec3i.class, new ICodecAction() {
            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                Vec3i v = (Vec3i)object;
                output.writeInt(v.getX());
                output.writeInt(v.getY());
                output.writeInt(v.getZ());
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                int x = input.readInt();
                int y = input.readInt();
                int z = input.readInt();
                return new Vec3i(x, y, z);
            }
        });

        codecActions.put(Vec3.class, new ICodecAction() {
            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                Vec3 v = (Vec3)object;
                output.writeDouble(v.x);
                output.writeDouble(v.y);
                output.writeDouble(v.z);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                double x = input.readDouble();
                double y = input.readDouble();
                double z = input.readDouble();
                return new Vec3(x, y, z);
            }
        });

        codecActions.put(Map.class, new ICodecAction() {

            // Packet structure:
            // Map length (int)
            // --- end if length == 0
            // Key class name (UTF)
            // Value class name (UTF)
            // for length
            //   key
            //   value

            @SuppressWarnings({ "rawtypes", "unchecked" })
            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                Map map = (Map) object;
                // Snapshot, so the written size matches the written entries if the map is modified concurrently.
                List<Map.Entry> entries = Lists.newArrayList(map.entrySet());
                output.writeInt(entries.size());
                ICodecAction keyAction = null;
                ICodecAction valueAction = null;
                for(Map.Entry entry : entries) {
                    if(keyAction == null) {
                        keyAction = getAction(entry.getKey().getClass());
                        output.writeUtf(entry.getKey().getClass().getName());
                    }
                    if(valueAction == null) {
                        valueAction = getAction(entry.getValue().getClass());
                        output.writeUtf(entry.getValue().getClass().getName());
                    }
                    keyAction.encode(entry.getKey(), output);
                    valueAction.encode(entry.getValue(), output);
                }
            }

            @SuppressWarnings({ "rawtypes", "unchecked" })
            @Override
            public Object decode(FriendlyByteBuf input) {
                Map map = Maps.newHashMap();
                int size = input.readInt();
                if(size == 0) {
                    return map;
                }
                try {
                    ICodecAction keyAction = getAction(Class.forName(input.readUtf(READ_STRING_MAX_LENGTH)));
                    ICodecAction valueAction = getAction(Class.forName(input.readUtf(READ_STRING_MAX_LENGTH)));
                    for(int i = 0; i < size; i++) {
                        Object key = keyAction.decode(input);
                        Object value = valueAction.decode(input);
                        map.put(key, value);
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                return map;
            }
        });

        codecActions.put(CompoundTag.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeNbt((CompoundTag) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readNbt();
            }
        });

        codecActions.put(Tag.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                CompoundTag tag = new CompoundTag();
                tag.put("v", (Tag) object);
                output.writeNbt(tag);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                CompoundTag tag = input.readNbt();
                return tag.get("v");
            }
        });

        codecActions.put(ItemStack.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeItem((ItemStack) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readItem();
            }
        });

        codecActions.put(FluidStack.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeNbt(((FluidStack) object).writeToNBT(new CompoundTag()));
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return FluidStack.loadFluidStackFromNBT(input.readNbt());
            }
        });

        codecActions.put(Direction.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeInt(((Direction) object).ordinal());
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return Direction.values()[input.readInt()];
            }
        });

        codecActions.put(BlockPos.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeBlockPos((BlockPos) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return input.readBlockPos();
            }
        });

        codecActions.put(ResourceKey.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeUtf(((ResourceKey) object).registry().toString());
                output.writeUtf(((ResourceKey) object).location().toString());
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return ResourceKey.create(
                        ResourceKey.createRegistryKey(new ResourceLocation(input.readUtf(READ_STRING_MAX_LENGTH))),
                        new ResourceLocation(input.readUtf(READ_STRING_MAX_LENGTH)));
            }
        });

        codecActions.put(DimPos.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                write(output, ((DimPos) object).getLevelKey());
                write(output, ((DimPos) object).getBlockPos());
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                ResourceKey dimensionType = read(input, ResourceKey.class);
                BlockPos blockPos = read(input, BlockPos.class);
                return DimPos.of(dimensionType, blockPos);
            }
        });

        codecActions.put(List.class, new ICodecAction() {

            // Packet structure:
            // list length (int)
            // --- end if length == 0
            // Value class name (UTF)
            //         id + value
            // -1

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                List<?> list = (List<?>) object;
                output.writeInt(list.size());
                if(list.size() == 0) return;
                ICodecAction valueAction = null;
                for(int i = 0; i < list.size(); i++) {
                    Object value = list.get(i);
                    if(value != null) {
                        if (valueAction == null) {
                            valueAction = getAction(value.getClass());
                            output.writeUtf(value.getClass().getName());
                        }
                        output.writeInt(i);
                        valueAction.encode(value, output);
                    }
                }
                if(valueAction == null) {
                    output.writeUtf("__noclass");
                } else {
                    output.writeInt(-1);
                }
            }

            @SuppressWarnings({ "rawtypes", "unchecked" })
            @Override
            public Object decode(FriendlyByteBuf input) {
                List list;
                int size = input.readInt();
                if(size == 0) {
                    return Collections.emptyList();
                } else {
                    list = Lists.newArrayListWithExpectedSize(size);
                }
                try {
                    String className = input.readUtf(READ_STRING_MAX_LENGTH);
                    if(!className.equals("__noclass")) {
                        ICodecAction valueAction = getAction(Class.forName(className));
                        int i, currentLength = 0;
                        while((i = input.readInt()) >= 0) {
                            while(currentLength < i) {
                                list.add(null);
                                currentLength++;
                            }
                            Object value = valueAction.decode(input);
                            list.add(value);
                            currentLength++;
                        }
                        while(currentLength < size) {
                            list.add(null);
                            currentLength++;
                        }
                    } else {
                        for (int i = 0; i < size; i++) {
                            list.add(null);
                        }
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                return list;
            }
        });

        codecActions.put(Pair.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                output.writeUtf(((Pair) object).getLeft().getClass().getName());
                output.writeUtf(((Pair) object).getRight().getClass().getName());
                write(output, ((Pair) object).getLeft());
                write(output, ((Pair) object).getRight());
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                try {
                    ICodecAction keyAction = getAction(Class.forName(input.readUtf(READ_STRING_MAX_LENGTH)));
                    ICodecAction valueAction = getAction(Class.forName(input.readUtf(READ_STRING_MAX_LENGTH)));
                    Object key = keyAction.decode(input);
                    Object value = valueAction.decode(input);
                    return Pair.of(key, value);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                return Pair.of(null, null);
            }
        });

        codecActions.put(ItemLocation.class, new ICodecAction() {

            @Override
            public void encode(Object object, FriendlyByteBuf output) {
                ItemLocation.writeToPacketBuffer(output, (ItemLocation) object);
            }

            @Override
            public Object decode(FriendlyByteBuf input) {
                return ItemLocation.readFromPacketBuffer(input);
            }
        });
    }

    /**
     * Register a new coded action.
     * @param clazz A class type.
     * @param action A codec action for the given type.
     */
    public static void addCodedAction(Class<?> clazz, ICodecAction action) {
        codecActions.put(clazz, action);
    }

    protected SingleCache<Void, List<Field>> fieldCache = new SingleCache<Void, List<Field>>(
            new SingleCache.ICacheUpdater<Void, List<Field>>() {

        @Override
        public List<Field> getNewValue(Void key) {
            List<Field> fieldList = Lists.newLinkedList();

            Class<?> clazz = PacketCodec.this.getClass();
            for (; clazz != PacketCodec.class && clazz != null; clazz = clazz.getSuperclass()) {
                Field[] fields = clazz.getDeclaredFields();

                // Sort this because the Java API tells us that getDeclaredFields()
                // does not deterministically define the order of the fields in the array.
                // Otherwise we might get nasty class cast exceptions when running in SMP.
                Arrays.sort(fields, new Comparator<Field>() {

                    @Override
                    public int compare(Field o1, Field o2) {
                        return o1.getName().compareTo(o2.getName());
                    }

                });

                for (final Field field : fields) {
                    if (field.isAnnotationPresent(CodecField.class)) {
                        fieldList.add(field);
                    }
                }
            }

            return fieldList;
        }

        @Override
        public boolean isKeyEqual(Void cacheKey, Void newKey) {
            return true;
        }

    });

    @Nullable
    protected static ICodecAction getActionSuper(Class<?> clazz) {
        if(ClassUtils.isPrimitiveWrapper(clazz)) {
            clazz = ClassUtils.wrapperToPrimitive(clazz);
        }
        ICodecAction action = codecActions.get(clazz);
        if(action == null) {
            for (Class<?> iface : clazz.getInterfaces()) {
                action = codecActions.get(iface);
                if (action != null) {
                    return action;
                }
            }
            Class<?> superClass = clazz.getSuperclass();
            if (superClass != null) {
                return getActionSuper(superClass);
            } else {
                return null;
            }
        }
        return action;
    }

    public static ICodecAction getAction(Class<?> clazz) {
        ICodecAction action = getActionSuper(clazz);
        if(action == null) {
            System.err.println("No ICodecAction was found for " + clazz
                    + ". You should add one in PacketCodec.");
        }
        return action;
    }

    private void loopCodecFields(ICodecRunnable runnable) {
        for (Field field : fieldCache.get(null)) {
            Class<?> clazz = field.getType();
            ICodecAction action = getAction(clazz);

            // Make private fields temporarily accessible.
            boolean accessible = field.isAccessible();
            if (!accessible) {
                field.setAccessible(true);
            }
            runnable.run(field, action);
        }
    }

    @Override
    public void encode(final FriendlyByteBuf output) {
        loopCodecFields((field, action) -> {
            Object object = null;
            try {
                object = field.get(PacketCodec.this);
            } catch (IllegalArgumentException | IllegalAccessException e) {
                e.printStackTrace();
            }
            action.encode(object, output);
        });
    }

    @Override
    public void decode(final FriendlyByteBuf input) {
        loopCodecFields((field, action) -> {
            Object object = action.decode(input);
            try {
                field.set(PacketCodec.this, object);
            } catch (IllegalArgumentException | IllegalAccessException e) {
                e.printStackTrace();
            }
        });
    }

    /**
     * Write the given object into the packet buffer.
     * @param packetBuffer A packet buffer.
     * @param object An object.
     */
    public static void write(FriendlyByteBuf packetBuffer, Object object) {
        ICodecAction action = Objects.requireNonNull(getActionSuper(object.getClass()),
                "No codec action was registered for " + object.getClass().getName());
        action.encode(object, packetBuffer);
    }

    /**
     * Read the an object of the given type from the packet buffer.
     * @param packetBuffer A packet buffer.
     * @param clazz The class type to read.
     * @param <T> The type of object.
     * @return The read object.
     */
    public static <T> T read(FriendlyByteBuf packetBuffer, Class<T> clazz) {
        ICodecAction action = Objects.requireNonNull(getActionSuper(clazz));
        return (T) action.decode(packetBuffer);
    }

    public static interface ICodecAction {

        /**
         * Encode the given object.
         * @param object The object to encode into the output.
         * @param output The byte array to encode to.
         */
        public void encode(Object object, FriendlyByteBuf output);

        /**
         * Decode from the input.
         * @param input The byte array to decode from.
         * @return The object to return after reading it from the input.
         */
        public Object decode(FriendlyByteBuf input);

    }

    public static interface ICodecRunnable {

        /**
         * Run a type of codec.
         * @param field The field annotated with {@link CodecField}.
         * @param action The action that must be applied to the field.
         */
        public void run(Field field, ICodecAction action);

    }

}

1	package org.cyclops.cyclopscore.network;
2
3	import com.google.common.collect.Lists;
4	import com.google.common.collect.Maps;
5	import net.minecraft.core.BlockPos;
6	import net.minecraft.core.Direction;
7	import net.minecraft.core.Vec3i;
8	import net.minecraft.nbt.CompoundTag;
9	import net.minecraft.nbt.Tag;
10	import net.minecraft.network.FriendlyByteBuf;
11	import net.minecraft.resources.ResourceKey;
12	import net.minecraft.resources.ResourceLocation;
13	import net.minecraft.world.item.ItemStack;
14	import net.minecraft.world.phys.Vec3;
15	import net.minecraftforge.fluids.FluidStack;
16	import org.apache.commons.lang3.ClassUtils;
17	import org.apache.commons.lang3.tuple.Pair;
18	import org.cyclops.cyclopscore.datastructure.DimPos;
19	import org.cyclops.cyclopscore.datastructure.SingleCache;
20	import org.cyclops.cyclopscore.inventory.ItemLocation;
21	import org.joml.Vector3d;
22
23	import javax.annotation.Nullable;
24	import java.lang.reflect.Field;
25	import java.util.Arrays;
26	import java.util.Collections;
27	import java.util.Comparator;
28	import java.util.List;
29	import java.util.Map;
30	import java.util.Objects;
31
32	/**
33	* Packet with automatic coding and decoding of basic fields annotated with {@link CodecField}.
34	* @author rubensworks
35	*
36	*/
37	public abstract class PacketCodec extends PacketBase {	1 ✔
38
39	public static final int READ_STRING_MAX_LENGTH = 32767;
40
41	private static Map<Class<?>, ICodecAction> codecActions = Maps.newHashMap();	1 ✔
42	static {
43	codecActions.put(String.class, new ICodecAction() {	1 ✔
44
45	@Override
46	public void encode(Object object, FriendlyByteBuf output) {
47	output.writeUtf((String) object);	1 ✔
48	}	1 ✔
49
50	@Override
51	public Object decode(FriendlyByteBuf input) {
52	return input.readUtf(32767); // The arg-less version is client-side only, so we copy its implementation.	1 ✔
53	}
54	});
55
56	codecActions.put(double.class, new ICodecAction() {	1 ✔
57
58	@Override
59	public void encode(Object object, FriendlyByteBuf output) {
60	output.writeDouble((Double) object);	1 ✔
61	}	1 ✔
62
63	@Override
64	public Object decode(FriendlyByteBuf input) {
65	return input.readDouble();	1 ✔
66	}
67	});
68
69	codecActions.put(int.class, new ICodecAction() {	1 ✔
70
71	@Override
72	public void encode(Object object, FriendlyByteBuf output) {
73	output.writeInt((int) object);	1 ✔
74	}	1 ✔
75
76	@Override
77	public Object decode(FriendlyByteBuf input) {
78	return input.readInt();	1 ✔
79	}
80	});
81
82	codecActions.put(long.class, new ICodecAction() {	1 ✔
83
84	@Override
85	public void encode(Object object, FriendlyByteBuf output) {
86	output.writeLong((long) object);	1 ✔
87	}	1 ✔
88
89	@Override
90	public Object decode(FriendlyByteBuf input) {
91	return input.readLong();	1 ✔
92	}
93	});
94
95	codecActions.put(short.class, new ICodecAction() {	1 ✔
96
97	@Override
98	public void encode(Object object, FriendlyByteBuf output) {
99	output.writeShort((Short) object);	1 ✔
100	}	1 ✔
101
102	@Override
103	public Object decode(FriendlyByteBuf input) {
104	return input.readShort();	1 ✔
105	}
106	});
107
108	codecActions.put(boolean.class, new ICodecAction() {	1 ✔
109
110	@Override
111	public void encode(Object object, FriendlyByteBuf output) {
112	output.writeBoolean((Boolean) object);	1 ✔
113	}	1 ✔
114
115	@Override
116	public Object decode(FriendlyByteBuf input) {
117	return input.readBoolean();	1 ✔
118	}
119	});
120
121	codecActions.put(float.class, new ICodecAction() {	1 ✔
122
123	@Override
124	public void encode(Object object, FriendlyByteBuf output) {
125	output.writeFloat((Float) object);	1 ✔
126	}	1 ✔
127
128	@Override
129	public Object decode(FriendlyByteBuf input) {
130	return input.readFloat();	1 ✔
131	}
132	});
133
134	codecActions.put(Vector3d.class, new ICodecAction() {	1 ✔
135	@Override
136	public void encode(Object object, FriendlyByteBuf output) {
137	Vector3d v = (Vector3d)object;	1 ✔
138	output.writeDouble(v.x);	1 ✔
139	output.writeDouble(v.y);	1 ✔
140	output.writeDouble(v.z);	1 ✔
141	}	1 ✔
142
143	@Override
144	public Object decode(FriendlyByteBuf input) {
145	double x = input.readDouble();	1 ✔
146	double y = input.readDouble();	1 ✔
147	double z = input.readDouble();	1 ✔
148	return new Vector3d(x, y, z);	1 ✔
149	}
150	});
151
152	codecActions.put(Vec3i.class, new ICodecAction() {	1 ✔
153	@Override
154	public void encode(Object object, FriendlyByteBuf output) {
155	Vec3i v = (Vec3i)object;	×
156	output.writeInt(v.getX());	×
157	output.writeInt(v.getY());	×
158	output.writeInt(v.getZ());	×
159	}	×
160
161	@Override
162	public Object decode(FriendlyByteBuf input) {
163	int x = input.readInt();	×
164	int y = input.readInt();	×
165	int z = input.readInt();	×
166	return new Vec3i(x, y, z);	×
167	}
168	});
169
170	codecActions.put(Vec3.class, new ICodecAction() {	1 ✔
171	@Override
172	public void encode(Object object, FriendlyByteBuf output) {
173	Vec3 v = (Vec3)object;	×
174	output.writeDouble(v.x);	×
175	output.writeDouble(v.y);	×
176	output.writeDouble(v.z);	×
177	}	×
178
179	@Override
180	public Object decode(FriendlyByteBuf input) {
181	double x = input.readDouble();	×
182	double y = input.readDouble();	×
183	double z = input.readDouble();	×
184	return new Vec3(x, y, z);	×
185	}
186	});
187
188	codecActions.put(Map.class, new ICodecAction() {	1 ✔
189
190	// Packet structure:
191	// Map length (int)
192	// --- end if length == 0
193	// Key class name (UTF)
194	// Value class name (UTF)
195	// for length
196	// key
197	// value
198
199	@SuppressWarnings({ "rawtypes", "unchecked" })
200	@Override
201	public void encode(Object object, FriendlyByteBuf output) {
202	Map map = (Map) object;	1 ✔
203	// Snapshot, so the written size matches the written entries if the map is modified concurrently.
204	List<Map.Entry> entries = Lists.newArrayList(map.entrySet());	1 ✔
205	output.writeInt(entries.size());	1 ✔
206	ICodecAction keyAction = null;	1 ✔
207	ICodecAction valueAction = null;	1 ✔
208	for(Map.Entry entry : entries) {	1 ✔
209	if(keyAction == null) {	1 ✔
210	keyAction = getAction(entry.getKey().getClass());	1 ✔
211	output.writeUtf(entry.getKey().getClass().getName());	1 ✔
212	}
213	if(valueAction == null) {	1 ✔
214	valueAction = getAction(entry.getValue().getClass());	1 ✔
215	output.writeUtf(entry.getValue().getClass().getName());	1 ✔
216	}
217	keyAction.encode(entry.getKey(), output);	1 ✔
218	valueAction.encode(entry.getValue(), output);	1 ✔
219	}	1 ✔
220	}	1 ✔
221
222	@SuppressWarnings({ "rawtypes", "unchecked" })
223	@Override
224	public Object decode(FriendlyByteBuf input) {
225	Map map = Maps.newHashMap();	1 ✔
226	int size = input.readInt();	1 ✔
227	if(size == 0) {	1 ✔
228	return map;	1 ✔
229	}
230	try {
231	ICodecAction keyAction = getAction(Class.forName(input.readUtf(READ_STRING_MAX_LENGTH)));	1 ✔
232	ICodecAction valueAction = getAction(Class.forName(input.readUtf(READ_STRING_MAX_LENGTH)));	1 ✔
233	for(int i = 0; i < size; i++) {	1 ✔
234	Object key = keyAction.decode(input);	1 ✔
235	Object value = valueAction.decode(input);	1 ✔
236	map.put(key, value);	1 ✔
237	}
238	} catch (ClassNotFoundException e) {	×
UNCOV 239	e.printStackTrace();	×
240	}	1 ✔
241	return map;	1 ✔
242	}
243	});
244
245	codecActions.put(CompoundTag.class, new ICodecAction() {	1 ✔
246
247	@Override
248	public void encode(Object object, FriendlyByteBuf output) {
249	output.writeNbt((CompoundTag) object);	1 ✔
250	}	1 ✔
251
252	@Override
253	public Object decode(FriendlyByteBuf input) {
254	return input.readNbt();	1 ✔
255	}
256	});
257
258	codecActions.put(Tag.class, new ICodecAction() {	1 ✔
259
260	@Override
261	public void encode(Object object, FriendlyByteBuf output) {
262	CompoundTag tag = new CompoundTag();	×
263	tag.put("v", (Tag) object);	×
264	output.writeNbt(tag);	×
UNCOV 265	}	×
266
267	@Override
268	public Object decode(FriendlyByteBuf input) {
269	CompoundTag tag = input.readNbt();	×
UNCOV 270	return tag.get("v");	×
271	}
272	});
273
274	codecActions.put(ItemStack.class, new ICodecAction() {	1 ✔
275
276	@Override
277	public void encode(Object object, FriendlyByteBuf output) {
278	output.writeItem((ItemStack) object);	×
UNCOV 279	}	×
280
281	@Override
282	public Object decode(FriendlyByteBuf input) {
UNCOV 283	return input.readItem();	×
284	}
285	});
286
287	codecActions.put(FluidStack.class, new ICodecAction() {	1 ✔
288
289	@Override
290	public void encode(Object object, FriendlyByteBuf output) {
291	output.writeNbt(((FluidStack) object).writeToNBT(new CompoundTag()));	×
UNCOV 292	}	×
293
294	@Override
295	public Object decode(FriendlyByteBuf input) {
UNCOV 296	return FluidStack.loadFluidStackFromNBT(input.readNbt());	×
297	}
298	});
299
300	codecActions.put(Direction.class, new ICodecAction() {	1 ✔
301
302	@Override
303	public void encode(Object object, FriendlyByteBuf output) {
304	output.writeInt(((Direction) object).ordinal());	1 ✔
305	}	1 ✔
306
307	@Override
308	public Object decode(FriendlyByteBuf input) {
309	return Direction.values()[input.readInt()];	1 ✔
310	}
311	});
312
313	codecActions.put(BlockPos.class, new ICodecAction() {	1 ✔
314
315	@Override
316	public void encode(Object object, FriendlyByteBuf output) {
317	output.writeBlockPos((BlockPos) object);	1 ✔
318	}	1 ✔
319
320	@Override
321	public Object decode(FriendlyByteBuf input) {
322	return input.readBlockPos();	1 ✔
323	}
324	});
325
326	codecActions.put(ResourceKey.class, new ICodecAction() {	1 ✔
327
328	@Override
329	public void encode(Object object, FriendlyByteBuf output) {
330	output.writeUtf(((ResourceKey) object).registry().toString());	×
331	output.writeUtf(((ResourceKey) object).location().toString());	×
UNCOV 332	}	×
333
334	@Override
335	public Object decode(FriendlyByteBuf input) {
336	return ResourceKey.create(	×
337	ResourceKey.createRegistryKey(new ResourceLocation(input.readUtf(READ_STRING_MAX_LENGTH))),	×
UNCOV 338	new ResourceLocation(input.readUtf(READ_STRING_MAX_LENGTH)));	×
339	}
340	});
341
342	codecActions.put(DimPos.class, new ICodecAction() {	1 ✔
343
344	@Override
345	public void encode(Object object, FriendlyByteBuf output) {
346	write(output, ((DimPos) object).getLevelKey());	×
347	write(output, ((DimPos) object).getBlockPos());	×
UNCOV 348	}	×
349
350	@Override
351	public Object decode(FriendlyByteBuf input) {
352	ResourceKey dimensionType = read(input, ResourceKey.class);	×
353	BlockPos blockPos = read(input, BlockPos.class);	×
UNCOV 354	return DimPos.of(dimensionType, blockPos);	×
355	}
356	});
357
358	codecActions.put(List.class, new ICodecAction() {	1 ✔
359
360	// Packet structure:
361	// list length (int)
362	// --- end if length == 0
363	// Value class name (UTF)
364	// id + value
365	// -1
366
367	@Override
368	public void encode(Object object, FriendlyByteBuf output) {
369	List<?> list = (List<?>) object;	1 ✔
370	output.writeInt(list.size());	1 ✔
371	if(list.size() == 0) return;	1 ✔
372	ICodecAction valueAction = null;	1 ✔
373	for(int i = 0; i < list.size(); i++) {	1 ✔
374	Object value = list.get(i);	1 ✔
375	if(value != null) {	1 ✔
376	if (valueAction == null) {	1 ✔
377	valueAction = getAction(value.getClass());	1 ✔
378	output.writeUtf(value.getClass().getName());	1 ✔
379	}
380	output.writeInt(i);	1 ✔
381	valueAction.encode(value, output);	1 ✔
382	}
383	}
384	if(valueAction == null) {	1 ✔
UNCOV 385	output.writeUtf("__noclass");	×
386	} else {
387	output.writeInt(-1);	1 ✔
388	}
389	}	1 ✔
390
391	@SuppressWarnings({ "rawtypes", "unchecked" })
392	@Override
393	public Object decode(FriendlyByteBuf input) {
394	List list;
395	int size = input.readInt();	1 ✔
396	if(size == 0) {	1 ✔
397	return Collections.emptyList();	1 ✔
398	} else {
399	list = Lists.newArrayListWithExpectedSize(size);	1 ✔
400	}
401	try {
402	String className = input.readUtf(READ_STRING_MAX_LENGTH);	1 ✔
403	if(!className.equals("__noclass")) {	1 ✔
404	ICodecAction valueAction = getAction(Class.forName(className));	1 ✔
405	int i, currentLength = 0;	1 ✔
406	while((i = input.readInt()) >= 0) {	1 ✔
407	while(currentLength < i) {	1 ✔
408	list.add(null);	1 ✔
409	currentLength++;	1 ✔
410	}
411	Object value = valueAction.decode(input);	1 ✔
412	list.add(value);	1 ✔
413	currentLength++;	1 ✔
414	}	1 ✔
415	while(currentLength < size) {	1 ✔
416	list.add(null);	1 ✔
417	currentLength++;	1 ✔
418	}
419	} else {	1 ✔
420	for (int i = 0; i < size; i++) {	×
UNCOV 421	list.add(null);	×
422	}
423	}
424	} catch (ClassNotFoundException e) {	×
UNCOV 425	e.printStackTrace();	×
426	}	1 ✔
427	return list;	1 ✔
428	}
429	});
430
431	codecActions.put(Pair.class, new ICodecAction() {	1 ✔
432
433	@Override
434	public void encode(Object object, FriendlyByteBuf output) {
435	output.writeUtf(((Pair) object).getLeft().getClass().getName());	×
436	output.writeUtf(((Pair) object).getRight().getClass().getName());	×
437	write(output, ((Pair) object).getLeft());	×
438	write(output, ((Pair) object).getRight());	×
UNCOV 439	}	×
440
441	@Override
442	public Object decode(FriendlyByteBuf input) {
443	try {
444	ICodecAction keyAction = getAction(Class.forName(input.readUtf(READ_STRING_MAX_LENGTH)));	×
445	ICodecAction valueAction = getAction(Class.forName(input.readUtf(READ_STRING_MAX_LENGTH)));	×
446	Object key = keyAction.decode(input);	×
447	Object value = valueAction.decode(input);	×
448	return Pair.of(key, value);	×
449	} catch (ClassNotFoundException e) {	×
UNCOV 450	e.printStackTrace();	×
451	}
UNCOV 452	return Pair.of(null, null);	×
453	}
454	});
455
456	codecActions.put(ItemLocation.class, new ICodecAction() {	1 ✔
457
458	@Override
459	public void encode(Object object, FriendlyByteBuf output) {
460	ItemLocation.writeToPacketBuffer(output, (ItemLocation) object);	×
UNCOV 461	}	×
462
463	@Override
464	public Object decode(FriendlyByteBuf input) {
UNCOV 465	return ItemLocation.readFromPacketBuffer(input);	×
466	}
467	});
468	}	1 ✔
469
470	/**
471	* Register a new coded action.
472	* @param clazz A class type.
473	* @param action A codec action for the given type.
474	*/
475	public static void addCodedAction(Class<?> clazz, ICodecAction action) {
476	codecActions.put(clazz, action);	×
UNCOV 477	}	×
478
479	protected SingleCache<Void, List<Field>> fieldCache = new SingleCache<Void, List<Field>>(	1 ✔
480	new SingleCache.ICacheUpdater<Void, List<Field>>() {	1 ✔
481
482	@Override
483	public List<Field> getNewValue(Void key) {
484	List<Field> fieldList = Lists.newLinkedList();	1 ✔
485
486	Class<?> clazz = PacketCodec.this.getClass();	1 ✔
487	for (; clazz != PacketCodec.class && clazz != null; clazz = clazz.getSuperclass()) {	1 ✔
488	Field[] fields = clazz.getDeclaredFields();	1 ✔
489
490	// Sort this because the Java API tells us that getDeclaredFields()
491	// does not deterministically define the order of the fields in the array.
492	// Otherwise we might get nasty class cast exceptions when running in SMP.
493	Arrays.sort(fields, new Comparator<Field>() {	1 ✔
494
495	@Override
496	public int compare(Field o1, Field o2) {
497	return o1.getName().compareTo(o2.getName());	1 ✔
498	}
499
500	});
501
502	for (final Field field : fields) {	1 ✔
503	if (field.isAnnotationPresent(CodecField.class)) {	1 ✔
504	fieldList.add(field);	1 ✔
505	}
506	}
507	}
508
509	return fieldList;	1 ✔
510	}
511
512	@Override
513	public boolean isKeyEqual(Void cacheKey, Void newKey) {
UNCOV 514	return true;	×
515	}
516
517	});
518
519	@Nullable
520	protected static ICodecAction getActionSuper(Class<?> clazz) {
521	if(ClassUtils.isPrimitiveWrapper(clazz)) {	1 ✔
522	clazz = ClassUtils.wrapperToPrimitive(clazz);	1 ✔
523	}
524	ICodecAction action = codecActions.get(clazz);	1 ✔
525	if(action == null) {	1 ✔
526	for (Class<?> iface : clazz.getInterfaces()) {	1 ✔
527	action = codecActions.get(iface);	1 ✔
528	if (action != null) {	1 ✔
529	return action;	1 ✔
530	}
531	}
532	Class<?> superClass = clazz.getSuperclass();	×
533	if (superClass != null) {	×
UNCOV 534	return getActionSuper(superClass);	×
535	} else {
UNCOV 536	return null;	×
537	}
538	}
539	return action;	1 ✔
540	}
541
542	public static ICodecAction getAction(Class<?> clazz) {
543	ICodecAction action = getActionSuper(clazz);	1 ✔
544	if(action == null) {	1 ✔
UNCOV 545	System.err.println("No ICodecAction was found for " + clazz	×
546	+ ". You should add one in PacketCodec.");
547	}
548	return action;	1 ✔
549	}
550
551	private void loopCodecFields(ICodecRunnable runnable) {
552	for (Field field : fieldCache.get(null)) {	1 ✔
553	Class<?> clazz = field.getType();	1 ✔
554	ICodecAction action = getAction(clazz);	1 ✔
555
556	// Make private fields temporarily accessible.
557	boolean accessible = field.isAccessible();	1 ✔
558	if (!accessible) {	1 ✔
559	field.setAccessible(true);	1 ✔
560	}
561	runnable.run(field, action);	1 ✔
562	}	1 ✔
563	}	1 ✔
564
565	@Override
566	public void encode(final FriendlyByteBuf output) {
567	loopCodecFields((field, action) -> {	1 ✔
568	Object object = null;	1 ✔
569	try {
570	object = field.get(PacketCodec.this);	1 ✔
571	} catch (IllegalArgumentException \| IllegalAccessException e) {	×
UNCOV 572	e.printStackTrace();	×
573	}	1 ✔
574	action.encode(object, output);	1 ✔
575	});	1 ✔
576	}	1 ✔
577
578	@Override
579	public void decode(final FriendlyByteBuf input) {
580	loopCodecFields((field, action) -> {	1 ✔
581	Object object = action.decode(input);	1 ✔
582	try {
583	field.set(PacketCodec.this, object);	1 ✔
584	} catch (IllegalArgumentException \| IllegalAccessException e) {	×
UNCOV 585	e.printStackTrace();	×
586	}	1 ✔
587	});	1 ✔
588	}	1 ✔
589
590	/**
591	* Write the given object into the packet buffer.
592	* @param packetBuffer A packet buffer.
593	* @param object An object.
594	*/
595	public static void write(FriendlyByteBuf packetBuffer, Object object) {
596	ICodecAction action = Objects.requireNonNull(getActionSuper(object.getClass()),	×
597	"No codec action was registered for " + object.getClass().getName());	×
598	action.encode(object, packetBuffer);	×
UNCOV 599	}	×
600
601	/**
602	* Read the an object of the given type from the packet buffer.
603	* @param packetBuffer A packet buffer.
604	* @param clazz The class type to read.
605	* @param <T> The type of object.
606	* @return The read object.
607	*/
608	public static <T> T read(FriendlyByteBuf packetBuffer, Class<T> clazz) {
609	ICodecAction action = Objects.requireNonNull(getActionSuper(clazz));	×
UNCOV 610	return (T) action.decode(packetBuffer);	×
611	}
612
613	public static interface ICodecAction {
614
615	/**
616	* Encode the given object.
617	* @param object The object to encode into the output.
618	* @param output The byte array to encode to.
619	*/
620	public void encode(Object object, FriendlyByteBuf output);
621
622	/**
623	* Decode from the input.
624	* @param input The byte array to decode from.
625	* @return The object to return after reading it from the input.
626	*/
627	public Object decode(FriendlyByteBuf input);
628
629	}
630
631	public static interface ICodecRunnable {
632
633	/**
634	* Run a type of codec.
635	* @param field The field annotated with {@link CodecField}.
636	* @param action The action that must be applied to the field.
637	*/
638	public void run(Field field, ICodecAction action);
639
640	}
641
642	}

CyclopsMC / CyclopsCore / #479033853

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous