andreacavalli/data-generator
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update data generator

Browse Source
This commit is contained in:
Andrea Cavalli 2021-05-25 11:17:44 +02:00
parent 5dafb52623
commit 7c4a569857
11 changed files with 150 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
src/main/java/it/cavallium/data/generator/SourcesGenerator.java
View File

@ -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.beginControlFlow("for (int i = 0; i < data.length; i++)");
serializeMethod.addStatement(typeSerializeStatement.get(substring).generate("data[i]"));
serializeMethod.addStatement("dataOutput.writeInt(data.size())");
serializeMethod.beginControlFlow("for (int i = 0; i < data.size(); 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.beginControlFlow("for (int i = 0; i < data.length; i++)");
deserializeMethod.addStatement(CodeBlock.join(List.of(CodeBlock.of("data[i] ="),
deserializeMethod.addStatement("int length = dataInput.readInt()");
deserializeMethod.addStatement("var data = new $T[length]", classType);
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.beginControlFlow("for (int i = 0; i < value.length; i++)");
deserializeMethod.addStatement("var item = value[i]", Array.class);
deserializeMethod.addStatement("var newArray = new $T[value.size()]", getArrayComponentType(toType));
deserializeMethod.beginControlFlow("for (int i = 0; i < value.size(); i++)");
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);
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArrayInt52Serializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
Int52Serializer.INSTANCE.serialize(dataOutput, data[i]);
public void serialize(DataOutput dataOutput, List<Int52> data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArrayStringSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeUTF(data[i]);
public void serialize(DataOutput dataOutput, @NotNull List<String> data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArraybooleanSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeBoolean(data[i]);
public void serialize(DataOutput dataOutput, @NotNull BooleanList data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArraybyteSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeByte(data[i]);
public void serialize(DataOutput dataOutput, @NotNull ByteList data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArraycharSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeChar(data[i]);
public void serialize(DataOutput dataOutput, @NotNull CharList data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArraydoubleSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeDouble(data[i]);
public void serialize(DataOutput dataOutput, @NotNull DoubleList data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArrayfloatSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeFloat(data[i]);
public void serialize(DataOutput dataOutput, @NotNull FloatList data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArrayintSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeInt(data[i]);
public void serialize(DataOutput dataOutput, @NotNull IntList data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArraylongSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeLong(data[i]);
public void serialize(DataOutput dataOutput, @NotNull LongList data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}

15
src/main/java/it/cavallium/data/generator/nativedata/ArrayshortSerializer.java
View File

@ -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 {
dataOutput.writeInt(data.length);
for (int i = 0; i < data.length; i++) {
dataOutput.writeShort(data[i]);
public void serialize(DataOutput dataOutput, @NotNull ShortList data) throws IOException {
dataOutput.writeInt(data.size());
for (int i = 0; i < data.size(); 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);
}
}