Update data generator

src/main/java/it/cavallium/data/generator/SourcesGenerator.java

@@ -18,9 +18,17 @@ import io.soabase.recordbuilder.core.RecordBuilder;
 import it.cavallium.data.generator.nativedata.IGenericNullable;
 import it.cavallium.data.generator.nativedata.Int52Serializer;
 import it.cavallium.data.generator.nativedata.StringSerializer;
+import it.unimi.dsi.fastutil.booleans.BooleanList;
+import it.unimi.dsi.fastutil.bytes.ByteList;
+import it.unimi.dsi.fastutil.chars.CharList;
+import it.unimi.dsi.fastutil.doubles.DoubleList;
+import it.unimi.dsi.fastutil.floats.FloatList;
+import it.unimi.dsi.fastutil.ints.IntList;
+import it.unimi.dsi.fastutil.longs.LongList;
 import it.unimi.dsi.fastutil.objects.Object2IntLinkedOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
+import it.unimi.dsi.fastutil.shorts.ShortList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.File;
@@ -587,14 +595,14 @@ public class SourcesGenerator {
 							ClassName.get("it.cavallium.data.generator.nativedata", "Nullable" + specialNativeType)
 					);
 					typeFamily.put("-" + specialNativeType, Family.NULLABLE_OTHER);
-					typeTypes.put("§" + specialNativeType, ArrayTypeName.of(typeTypes.get(specialNativeType)));
+					typeTypes.put("§" + specialNativeType, getImmutableArrayType(typeTypes, specialNativeType));
 					typeFamily.put("§" + specialNativeType, Family.OTHER);
 					if (nextVersion.isPresent()) {
 						nextVersionTypeTypes.put("-" + specialNativeType,
 								ClassName.get("it.cavallium.data.generator.nativedata", "Nullable" + specialNativeType)
 						);
 						nextVersionTypeFamily.put("-" + specialNativeType, Family.NULLABLE_OTHER);
-						nextVersionTypeTypes.put("§" + specialNativeType, ArrayTypeName.of(typeTypes.get(specialNativeType)));
+						nextVersionTypeTypes.put("§" + specialNativeType, getImmutableArrayType(typeTypes, specialNativeType));
 						nextVersionTypeFamily.put("§" + specialNativeType, Family.OTHER);
 					}
 					typeOptionalSerializers.put("-" + specialNativeType,
@@ -991,7 +999,7 @@ public class SourcesGenerator {
 						if (typeMustGenerateSerializer.get(type)) {
 							String substring = type.substring(1);
 							var classType = ClassName.get(joinPackage(versionPackage, "data"), substring);
-							var arrayClassType = ArrayTypeName.of(classType);
+							var arrayClassType = getImmutableArrayType(classType);
 
 							// Create the array X serializer class
 							{
@@ -1018,22 +1026,26 @@ public class SourcesGenerator {
 								// Create the serialize method
 								{
 									var serializeMethod = createEmptySerializeMethod(arrayClassType);
-									serializeMethod.addStatement("dataOutput.writeInt(data.length)");
+									serializeMethod.addStatement("dataOutput.writeInt(data.size())");
-									serializeMethod.beginControlFlow("for (int i = 0; i < data.length; i++)");
+									serializeMethod.beginControlFlow("for (int i = 0; i < data.size(); i++)");
-									serializeMethod.addStatement(typeSerializeStatement.get(substring).generate("data[i]"));
+									serializeMethod.addStatement(typeSerializeStatement.get(substring).generate("data.get(i)"));
 									serializeMethod.endControlFlow();
 									arraySerializerClass.addMethod(serializeMethod.build());
 								}
 								// Create the deserialize method
 								{
 									var deserializeMethod = createEmptyDeserializeMethod(arrayClassType);
-									deserializeMethod.addStatement("var data = new $T[dataInput.readInt()]", classType);
+									deserializeMethod.addStatement("int length = dataInput.readInt()");
-									deserializeMethod.beginControlFlow("for (int i = 0; i < data.length; i++)");
+									deserializeMethod.addStatement("var data = new $T[length]", classType);
-									deserializeMethod.addStatement(CodeBlock.join(List.of(CodeBlock.of("data[i] ="),
+									deserializeMethod.beginControlFlow("for (int i = 0; i < length; i++)");
+									deserializeMethod.addStatement(CodeBlock.join(List.of(CodeBlock.of("data[i] = "),
 											typeDeserializeStatement.get(substring)
-									), " "));
+									), ""));
 									deserializeMethod.endControlFlow();
-									deserializeMethod.addStatement("return data");
+									deserializeMethod.addStatement("return $T.of(data)",
+											(arrayClassType instanceof ParameterizedTypeName
+													? ((ParameterizedTypeName) arrayClassType).rawType : arrayClassType)
+									);
 									arraySerializerClass.addMethod(deserializeMethod.build());
 								}
 								// Save the resulting class in the main package
@@ -2249,6 +2261,43 @@ public class SourcesGenerator {
 		}
 	}
 
+	private TypeName getImmutableArrayType(HashMap<String, TypeName> typeTypes, String typeString) {
+		var type = typeTypes.get(typeString);
+		return getImmutableArrayType(type);
+	}
+
+	private TypeName getImmutableArrayType(TypeName type) {
+		return switch (type.toString()) {
+			case "boolean" -> ClassName.get(BooleanList.class);
+			case "byte" -> ClassName.get(ByteList.class);
+			case "short" -> ClassName.get(ShortList.class);
+			case "char" -> ClassName.get(CharList.class);
+			case "int" -> ClassName.get(IntList.class);
+			case "long" -> ClassName.get(LongList.class);
+			case "float" -> ClassName.get(FloatList.class);
+			case "double" -> ClassName.get(DoubleList.class);
+			default -> ParameterizedTypeName.get(ClassName.get(List.class), type);
+		};
+	}
+
+	private TypeName getArrayComponentType(TypeName listType) {
+		if (listType instanceof ParameterizedTypeName) {
+			return ((ParameterizedTypeName) listType).typeArguments.get(0);
+		} else {
+			return switch (listType.toString()) {
+				case "BooleanList" -> ClassName.BOOLEAN;
+				case "ByteList" -> ClassName.BYTE;
+				case "ShortList" -> ClassName.SHORT;
+				case "CharList" -> ClassName.CHAR;
+				case "IntList" -> ClassName.INT;
+				case "LongList" -> ClassName.LONG;
+				case "FloatList" -> ClassName.FLOAT;
+				case "DoubleList" -> ClassName.DOUBLE;
+				default -> throw new IllegalStateException("Unexpected value: " + listType);
+			};
+		}
+	}
+
 	private CodeBlock buildStatementUpgradeBasicType(
 			String versionPackage,
 			String nextVersionPackage,
@@ -2421,29 +2470,26 @@ public class SourcesGenerator {
 		deserializeMethod.beginControlFlow("");
 		deserializeMethod.addStatement("var value = $N", inputFieldName);
 
-		var oldIType = ClassName.get(joinPackage(versionPackage, "data"), "IType");
-		var oldITypeArray = ArrayTypeName.of(oldIType);
-
-		var newIType = ClassName.get(joinPackage(Objects.requireNonNull(nextVersionPackage), "data"), "IType");
-		var newITypeArray = ArrayTypeName.of(newIType);
-
 		var oldVersionType = ClassName.get(joinPackage(versionPackage, ""), "Version");
 		var oldIBasicType = ClassName.get(joinPackage(versionPackage, "data"), "IBasicType");
 		var oldINullableBasicType = ClassName.get(joinPackage(versionPackage, "data.nullables"),
 				"INullableBasicType"
 		);
 		deserializeMethod.addStatement("$T.requireNonNull(value)", Objects.class);
-		deserializeMethod.addStatement("var newArray = new $T[value.length]", ((ArrayTypeName) toTypeBoxed).componentType);
+		deserializeMethod.addStatement("var newArray = new $T[value.size()]", getArrayComponentType(toType));
-		deserializeMethod.beginControlFlow("for (int i = 0; i < value.length; i++)");
+		deserializeMethod.beginControlFlow("for (int i = 0; i < value.size(); i++)");
-		deserializeMethod.addStatement("var item = value[i]", Array.class);
+		deserializeMethod.addStatement("var item = value.get(i)", Array.class);
 		deserializeMethod.addStatement("var updatedItem = ($T) $T.upgradeToNextVersion(($T) item)",
-				((ArrayTypeName) toTypeBoxed).componentType,
+				getArrayComponentType(toType),
 				oldVersionType,
 				oldIBasicType
 		);
 		deserializeMethod.addStatement("newArray[i] = updatedItem");
 		deserializeMethod.endControlFlow();
-		deserializeMethod.addStatement("$N = newArray", resultFieldName);
+		deserializeMethod.addStatement("$N = $T.of(newArray)",
+				resultFieldName,
+				toType instanceof ParameterizedTypeName ? ((ParameterizedTypeName) toType).rawType : toType
+		);
 
 
 		deserializeMethod.endControlFlow();
@@ -2606,13 +2652,13 @@ public class SourcesGenerator {
 					typeMustGenerateSerializer,
 					type
 			);
-			typeTypes.put("§" + type, ArrayTypeName.of(arrayClassName.get()));
+			typeTypes.put("§" + type, getImmutableArrayType(arrayClassName.get()));
 			typeFamily.put("§" + type, Family.I_TYPE_ARRAY);
 		}
 		if (nextVersionArrayTypeNeeded) {
 			assert nextVersionTypeTypes != null;
 			assert nextVersionTypeFamily != null;
-			nextVersionTypeTypes.put("§" + type, ArrayTypeName.of(nextArrayClassName.get()));
+			nextVersionTypeTypes.put("§" + type, getImmutableArrayType(nextArrayClassName.get()));
 			nextVersionTypeFamily.put("§" + type, Family.I_TYPE_ARRAY);
 		}
 

src/main/java/it/cavallium/data/generator/nativedata/ArrayInt52Serializer.java

@@ -4,25 +4,26 @@ import it.cavallium.data.generator.DataSerializer;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
+import java.util.List;
 import org.jetbrains.annotations.NotNull;
 
-public class ArrayInt52Serializer implements DataSerializer<Int52[]> {
+public class ArrayInt52Serializer implements DataSerializer< List<Int52>> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull Int52[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, List<Int52> data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			Int52Serializer.INSTANCE.serialize(dataOutput, data[i]);
+			Int52Serializer.INSTANCE.serialize(dataOutput, data.get(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public Int52[] deserialize(DataInput dataInput) throws IOException {
+	public List<Int52> deserialize(DataInput dataInput) throws IOException {
 		var data = new Int52[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = Int52Serializer.INSTANCE.deserialize(dataInput);
 		}
-		return data;
+		return List.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArrayStringSerializer.java

@@ -4,25 +4,26 @@ import it.cavallium.data.generator.DataSerializer;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
+import java.util.List;
 import org.jetbrains.annotations.NotNull;
 
-public class ArrayStringSerializer implements DataSerializer<String[]> {
+public class ArrayStringSerializer implements DataSerializer<List<String>> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull String[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull List<String> data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeUTF(data[i]);
+			dataOutput.writeUTF(data.get(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public String[] deserialize(DataInput dataInput) throws IOException {
+	public List<String> deserialize(DataInput dataInput) throws IOException {
 		var data = new String[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readUTF();
 		}
-		return data;
+		return List.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArraybooleanSerializer.java

@@ -1,28 +1,29 @@
 package it.cavallium.data.generator.nativedata;
 
 import it.cavallium.data.generator.DataSerializer;
+import it.unimi.dsi.fastutil.booleans.BooleanList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import org.jetbrains.annotations.NotNull;
 
-public class ArraybooleanSerializer implements DataSerializer<boolean[]> {
+public class ArraybooleanSerializer implements DataSerializer<BooleanList> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull boolean[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull BooleanList data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeBoolean(data[i]);
+			dataOutput.writeBoolean(data.getBoolean(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public boolean[] deserialize(DataInput dataInput) throws IOException {
+	public BooleanList deserialize(DataInput dataInput) throws IOException {
 		var data = new boolean[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readBoolean();
 		}
-		return data;
+		return BooleanList.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArraybyteSerializer.java

@@ -1,28 +1,29 @@
 package it.cavallium.data.generator.nativedata;
 
 import it.cavallium.data.generator.DataSerializer;
+import it.unimi.dsi.fastutil.bytes.ByteList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import org.jetbrains.annotations.NotNull;
 
-public class ArraybyteSerializer implements DataSerializer<byte[]> {
+public class ArraybyteSerializer implements DataSerializer<ByteList> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull byte[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull ByteList data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeByte(data[i]);
+			dataOutput.writeByte(data.getByte(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public byte[] deserialize(DataInput dataInput) throws IOException {
+	public ByteList deserialize(DataInput dataInput) throws IOException {
 		var data = new byte[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readByte();
 		}
-		return data;
+		return ByteList.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArraycharSerializer.java

@@ -1,28 +1,29 @@
 package it.cavallium.data.generator.nativedata;
 
 import it.cavallium.data.generator.DataSerializer;
+import it.unimi.dsi.fastutil.chars.CharList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import org.jetbrains.annotations.NotNull;
 
-public class ArraycharSerializer implements DataSerializer<char[]> {
+public class ArraycharSerializer implements DataSerializer<CharList> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull char[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull CharList data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeChar(data[i]);
+			dataOutput.writeChar(data.getChar(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public char[] deserialize(DataInput dataInput) throws IOException {
+	public CharList deserialize(DataInput dataInput) throws IOException {
 		var data = new char[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readChar();
 		}
-		return data;
+		return CharList.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArraydoubleSerializer.java

@@ -1,28 +1,29 @@
 package it.cavallium.data.generator.nativedata;
 
 import it.cavallium.data.generator.DataSerializer;
+import it.unimi.dsi.fastutil.doubles.DoubleList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import org.jetbrains.annotations.NotNull;
 
-public class ArraydoubleSerializer implements DataSerializer<double[]> {
+public class ArraydoubleSerializer implements DataSerializer<DoubleList> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull double[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull DoubleList data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeDouble(data[i]);
+			dataOutput.writeDouble(data.getDouble(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public double[] deserialize(DataInput dataInput) throws IOException {
+	public DoubleList deserialize(DataInput dataInput) throws IOException {
 		var data = new double[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readDouble();
 		}
-		return data;
+		return DoubleList.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArrayfloatSerializer.java

@@ -1,28 +1,29 @@
 package it.cavallium.data.generator.nativedata;
 
 import it.cavallium.data.generator.DataSerializer;
+import it.unimi.dsi.fastutil.floats.FloatList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import org.jetbrains.annotations.NotNull;
 
-public class ArrayfloatSerializer implements DataSerializer<float[]> {
+public class ArrayfloatSerializer implements DataSerializer<FloatList> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull float[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull FloatList data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeFloat(data[i]);
+			dataOutput.writeFloat(data.getFloat(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public float[] deserialize(DataInput dataInput) throws IOException {
+	public FloatList deserialize(DataInput dataInput) throws IOException {
 		var data = new float[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readFloat();
 		}
-		return data;
+		return FloatList.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArrayintSerializer.java

@@ -1,28 +1,29 @@
 package it.cavallium.data.generator.nativedata;
 
 import it.cavallium.data.generator.DataSerializer;
+import it.unimi.dsi.fastutil.ints.IntList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import org.jetbrains.annotations.NotNull;
 
-public class ArrayintSerializer implements DataSerializer<int[]> {
+public class ArrayintSerializer implements DataSerializer<IntList> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull int[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull IntList data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeInt(data[i]);
+			dataOutput.writeInt(data.getInt(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public int[] deserialize(DataInput dataInput) throws IOException {
+	public IntList deserialize(DataInput dataInput) throws IOException {
 		var data = new int[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readInt();
 		}
-		return data;
+		return IntList.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArraylongSerializer.java

@@ -1,28 +1,29 @@
 package it.cavallium.data.generator.nativedata;
 
 import it.cavallium.data.generator.DataSerializer;
+import it.unimi.dsi.fastutil.longs.LongList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import org.jetbrains.annotations.NotNull;
 
-public class ArraylongSerializer implements DataSerializer<long[]> {
+public class ArraylongSerializer implements DataSerializer<LongList> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull long[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull LongList data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeLong(data[i]);
+			dataOutput.writeLong(data.getLong(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public long[] deserialize(DataInput dataInput) throws IOException {
+	public LongList deserialize(DataInput dataInput) throws IOException {
 		var data = new long[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readLong();
 		}
-		return data;
+		return LongList.of(data);
 	}
 }

src/main/java/it/cavallium/data/generator/nativedata/ArrayshortSerializer.java

@@ -1,28 +1,29 @@
 package it.cavallium.data.generator.nativedata;
 
 import it.cavallium.data.generator.DataSerializer;
+import it.unimi.dsi.fastutil.shorts.ShortList;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.IOException;
 import org.jetbrains.annotations.NotNull;
 
-public class ArrayshortSerializer implements DataSerializer<short[]> {
+public class ArrayshortSerializer implements DataSerializer<ShortList> {
 
 	@Override
-	public void serialize(DataOutput dataOutput, @NotNull short[] data) throws IOException {
+	public void serialize(DataOutput dataOutput, @NotNull ShortList data) throws IOException {
-		dataOutput.writeInt(data.length);
+		dataOutput.writeInt(data.size());
-		for (int i = 0; i < data.length; i++) {
+		for (int i = 0; i < data.size(); i++) {
-			dataOutput.writeShort(data[i]);
+			dataOutput.writeShort(data.getShort(i));
 		}
 	}
 
 	@NotNull
 	@Override
-	public short[] deserialize(DataInput dataInput) throws IOException {
+	public ShortList deserialize(DataInput dataInput) throws IOException {
 		var data = new short[dataInput.readInt()];
 		for (int i = 0; i < data.length; i++) {
 			data[i] = dataInput.readShort();
 		}
-		return data;
+		return ShortList.of(data);
 	}
 }